home *** CD-ROM | disk | FTP | other *** search
/ Chip 2005 August (Alt) / CHIP 2005-08.1.iso / program / guvenlik / syslinux-3.07.exe / com32 / libutil / get_key.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-01-04  |  4.7 KB  |  170 lines
  1. #ident "$Id: get_key.c,v 1.5 2005/01/04 07:15:20 hpa Exp $"
  2. /* ----------------------------------------------------------------------- *
  3.  *   
  4.  *   Copyright 2004 H. Peter Anvin - All Rights Reserved
  5.  *
  6.  *   Permission is hereby granted, free of charge, to any person
  7.  *   obtaining a copy of this software and associated documentation
  8.  *   files (the "Software"), to deal in the Software without
  9.  *   restriction, including without limitation the rights to use,
  10.  *   copy, modify, merge, publish, distribute, sublicense, and/or
  11.  *   sell copies of the Software, and to permit persons to whom
  12.  *   the Software is furnished to do so, subject to the following
  13.  *   conditions:
  14.  *   
  15.  *   The above copyright notice and this permission notice shall
  16.  *   be included in all copies or substantial portions of the Software.
  17.  *   
  18.  *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19.  *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  20.  *   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21.  *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  22.  *   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23.  *   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  24.  *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25.  *   OTHER DEALINGS IN THE SOFTWARE.
  26.  *
  27.  * ----------------------------------------------------------------------- */
  28.  
  29. /*
  30.  * get_key.c
  31.  *
  32.  * Get a single key, and try to pick apart function key codes.
  33.  * This doesn't decode anywhere close to all possiblities, but
  34.  * hopefully is enough to be useful.
  35.  */
  36.  
  37. #include <stdio.h>
  38. #include <string.h>
  39. #include <errno.h>
  40. #include <unistd.h>
  41. #include <time.h>
  42. #include <sys/times.h>
  43. #include <getkey.h>
  44.  
  45. struct keycode {
  46.   int code;
  47.   int seqlen;
  48.   const unsigned char *seq;
  49. };
  50.  
  51. #define MAXLEN 8
  52. #define CODE(x,y) { x, (sizeof y)-1, y }
  53.  
  54. static const struct keycode keycodes[] = {
  55.   /* First, the BIOS combined codes */
  56.   CODE(KEY_F1,   "\0\x3B"),
  57.   CODE(KEY_F2,   "\0\x3C"),
  58.   CODE(KEY_F3,   "\0\x3D"),
  59.   CODE(KEY_F4,   "\0\x3E"),
  60.   CODE(KEY_F5,   "\0\x3F"),
  61.   CODE(KEY_F6,   "\0\x40"),
  62.   CODE(KEY_F7,   "\0\x41"),
  63.   CODE(KEY_F8,   "\0\x42"),
  64.   CODE(KEY_F9,   "\0\x43"),
  65.   CODE(KEY_F10,  "\0\x44"),
  66.   CODE(KEY_F11,  "\0\x85"),
  67.   CODE(KEY_F12,  "\0\x86"),
  68.  
  69.   CODE(KEY_UP,   "\0\x48"),
  70.   CODE(KEY_DOWN, "\0\x50"),
  71.   CODE(KEY_LEFT, "\0\x4B"),
  72.   CODE(KEY_RIGHT,"\0\x4D"),
  73.   CODE(KEY_PGUP, "\0\x49"),
  74.   CODE(KEY_PGDN, "\0\x51"),
  75.   CODE(KEY_HOME, "\0\x47"),
  76.   CODE(KEY_END,  "\0\x4F"),
  77.   CODE(KEY_INS,  "\0\x52"),
  78.   CODE(KEY_DEL,  "\0\x53"),
  79.  
  80.   /* Now, VT/xterm/Linux codes */
  81.   CODE(KEY_F1,   "\033[[A"),
  82.   CODE(KEY_F1,   "\033OP"),
  83.   CODE(KEY_F2,   "\033[[B"),
  84.   CODE(KEY_F2,   "\033OQ"),
  85.   CODE(KEY_F3,   "\033[[C"),
  86.   CODE(KEY_F3,   "\033OR"),
  87.   CODE(KEY_F4,   "\033[[D"),
  88.   CODE(KEY_F4,   "\033OS"),
  89.   CODE(KEY_F5,   "\033[[E"),
  90.   CODE(KEY_F5,   "\033[15~"),
  91.   CODE(KEY_F6,   "\033[17~"),
  92.   CODE(KEY_F7,   "\033[18~"),
  93.   CODE(KEY_F8,   "\033[19~"),
  94.   CODE(KEY_F9,   "\033[20~"),
  95.   CODE(KEY_F10,  "\033[21~"),
  96.   CODE(KEY_F11,  "\033[23~"),
  97.   CODE(KEY_F12,  "\033[24~"),
  98.  
  99.   CODE(KEY_UP,   "\033[A"),
  100.   CODE(KEY_DOWN, "\033[B"),
  101.   CODE(KEY_LEFT, "\033[D"),
  102.   CODE(KEY_RIGHT,"\033[C"),
  103.   CODE(KEY_PGUP, "\033[5~"),
  104.   CODE(KEY_PGUP, "\033[V"),
  105.   CODE(KEY_PGDN, "\033[6~"),
  106.   CODE(KEY_PGDN, "\033[U"),
  107.   CODE(KEY_HOME, "\033[1~"),
  108.   CODE(KEY_HOME, "\033[H"),
  109.   CODE(KEY_END,  "\033[4~"),
  110.   CODE(KEY_END,  "\033[F"),
  111.   CODE(KEY_END,  "\033OF"),
  112.   CODE(KEY_INS,  "\033[2~"),
  113.   CODE(KEY_INS,  "\033[@"),
  114.   CODE(KEY_DEL,  "\033[3~"),
  115. };
  116. #define NCODES ((int)(sizeof keycodes/sizeof(struct keycode)))
  117.  
  118. int get_key(FILE *f, clock_t timeout)
  119. {
  120.   unsigned char buffer[MAXLEN];
  121.   int nc, i, rv;
  122.   const struct keycode *kc;
  123.   int another;
  124.   unsigned char ch;
  125.   clock_t start;
  126.  
  127.   /* We typically start in the middle of a clock tick */
  128.   if ( timeout )
  129.     timeout++;
  130.  
  131.   nc = 0;
  132.   start = times(NULL);
  133.   do {
  134.     rv = read(fileno(f), &ch, 1);
  135.     if ( rv == 0 || (rv == -1 && errno == EAGAIN) ) {
  136.       clock_t lateness = times(NULL)-start;
  137.       if ( nc && lateness > 1+CLK_TCK/20 )
  138.     return buffer[0];    /* timeout in sequence */
  139.       else if ( !nc && timeout && lateness > timeout )
  140.     return KEY_NONE;    /* timeout before sequence */
  141.  
  142.       another = 1;
  143.       continue;
  144.     }
  145.  
  146.     start = times(NULL);
  147.  
  148.     buffer[nc++] = ch;
  149.  
  150.     another = 0;
  151.     for ( i = 0, kc = keycodes ; i < NCODES ; i++, kc++ ) {
  152.       if ( nc == kc->seqlen && !memcmp(buffer, kc->seq, nc) )
  153.     return kc->code;
  154.       else if ( nc < kc->seqlen && !memcmp(buffer, kc->seq, nc) ) {
  155.     another = 1;
  156.     break;
  157.       }
  158.     }
  159.   } while ( another );
  160.  
  161.   /* We got an unrecognized sequence; return the first character */
  162.   /* We really should remember this and return subsequent characters later */
  163.   return buffer[0];
  164. }
  165.     
  166.  
  167.     
  168.  
  169.     
  170.